﻿#include<iostream>
using namespace std;

//inline int Add(int x, int y) 
//{
//	int ret = x + y;
//	ret += 1;
//	return ret;
//}
//
//int main()
//{
//	int ret = Add(1, 2);
//	cout << Add(1, 2)*5 << endl;
//	return 0;
//}

//// 1. 宏定义
//#define SQURE(x) ((x) * (x))
//
//// 2. 内联函数
//inline int square_inline(int x) 
//{
//    return x * x;
//}
//
//// 3. 普通函数
//int square_puto(int x) 
//{
//    return x * x;
//}
//
//int main() 
//{
//    int a = 5;
//
//    cout << "宏定义: " << SQURE(a) << endl;       // 输出 25
//    cout << "内联函数: " << square_inline(a) << endl;    // 输出 25
//    cout << "普通函数: " << square_puto(a) << endl;    // 输出 25
//
//    //副作用风险
//    a = 5;//返回5，重新测
//    int result_hong = SQURE(a++);      //不安全，展开为 ((a++) * (a++))
//    cout << "宏定义结果: " << result_hong << ", 执行后a的值: " << a << endl; // a被递增了两次！
//    
//    a = 5;
//    int result_inline = square_inline(a++); // 安全，a++先求值（5），然后a自增到6
//    cout << "内联函数结果: " << result_inline << ", 执行后a的值: " << a << endl;
//    
//    a = 5;
//    int result_puto = square_puto(a++); // 安全，行为与内联函数相同
//    cout << "普通函数结果: " << result_puto << ", 执行后a的值: " << a << endl;
//
//    return 0;
//}

//引用


//void Swap(int& rx, int& ry)
//{
//	int tmp = rx;
//	rx = ry;
//	ry = tmp;
//}
//int main()
//{
//	int a = 0;
//	int& b = a;//b是a的别名(引用)
//	b = 2;//相当于a=2
//	cout << " " << b << endl;
//
//	int x = 0, y = 1;
//	cout << x << " " << y << endl;
//	Swap(x, y);//引用转参
//	cout << x << " " << y << endl;
//	return 0;
//}

//int main()
//{
//	const int a = 10;
//	//int& ra = a;
//	// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &”
//	// 这⾥的引⽤是对a访问权限的放⼤
//	
//	// 这样才可以
//	const int& ra = a;
//	//ra++;
//	// 编译报错：error C3892: “ra”: 不能给常量赋值
//	
//	int b = 20;
//	const int& rb = b;
//	// 这⾥的引⽤是对b访问权限的缩⼩
//	//rb++;
//	// 编译报错：error C3892: “rb”: 不能给常量赋值
//	
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	const int& ra = 30;
//	// 编译报错: “初始化”: ⽆法从“int”转换为“int &”
//	//int& rb = a * 3;
//	//const int& rb = a * 3;
//	//double d = 12.34;
//	// 编译报错：“初始化”: ⽆法从“double”转换为“int &”
//	// int& rd = d;
//	//const int& rd = d;
//	return 0;
//}

int main() {
    int a = 100;
    double pi = 3.14;

    // 普通引用的绑定限制
    // int &r1 = 100;     // 不能绑定到字面量（右值）
    // int &r2 = a * 2;   // 不能绑定到表达式结果（右值）
    // int &r3 = pi;      // 类型不匹配，且涉及临时对象

    // const引用的灵活性
    const int& ra1 = 100;   // 可以绑定到变量
    const int& ra2 = a * 2; // 可以绑定到表达式结果
    const int& ra3 = pi;    // 允许类型转换（实际绑定到临时int变量）

    return 0;
}